/*
Problem Description
度熊手上有一本神奇的字典，你可以在它里面做如下三个操作：

1、insert : 往神奇字典中插入一个单词

2、delete: 在神奇字典中删除所有前缀等于给定字符串的单词

3、search: 查询是否在神奇字典中有一个字符串的前缀等于给定的字符串
Input
这里仅有一组测试数据。第一行输入一个正整数N (1\leq N\leq 100000)N(1≤N≤100000)，代表度熊对于字典的操作次数，接下来NN行，每行包含两个字符串，中间中用空格隔开。第一个字符串代表了相关的操作（包括： insert, delete 或者 search）。第二个字符串代表了相关操作后指定的那个字符串，第二个字符串的长度不会超过30。第二个字符串仅由小写字母组成。

Output
对于每一个search 操作，如果在度熊的字典中存在给定的字符串为前缀的单词，则输出Yes 否则输出 No。

Sample Input
5
insert hello
insert hehe
search h
delete he
search hello
Sample Output
Yes
No
 */
package com.yuan.algorithms.competition2016;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

/**
 * @author YouYuan
 * @contact 1265161633@qq.com
 * @date 2016年5月15日 下午7:32:42
 * @descript 字典树解答。注意：自己是自己的前缀；delete删除的是单词！search查找的是字符串！
 */
class Trie{
	private int SIZE = 26;
	private Node root;//根节点
	
	public Trie() {
		root = new Node();
	}
	
	private class Node{
		private int num;//当前节点字符被引用的次数
		private Node[] son;//保存所有子节点的数组
		private char val;//字符值
		private boolean isEnd;//是否为叶子节点（最后一个节点），每个叶子节点代表一个字符串
		
		public Node() {
			//初始化
			num = 1;
			son = new Node[SIZE];
			isEnd = false;
		}
	}
	
	public void insert(String data) {
		if (data == null || data.length() == 0) {
			return;
		}
		char[] arr = data.toCharArray();
		Node node = root;
		for (int i = 0; i < arr.length; i++) {
			int index = arr[i] - 'a';
			if (node.son[index] == null) {//字符节点不存在，创建新的节点存储字符
				node.son[index] = new Node();
				node.son[index].val = arr[i];
			} else {
				node.son[index].num++;//字符已存在，引用数+1
			}
			node = node.son[index];// 延伸树的深度存储下一个值
		}
		node.isEnd = true;//标记为字符串的最后一个字符
	}

	public void delete(String data) {
		if (data == null || data.length() == 0) {
			return;
		}
		char[] arr = data.toCharArray();
		Node node = root;
		for (int i = 0; i < arr.length; i++) {
			int index = arr[i] - 'a';
			if (node.son[index] == null) {
				return;
			} else {
				if (i == arr.length - 1) {
					node.son[index] = null;
					return;
				} else {
					node = node.son[index];
				}
			}
		}
//		recursionDelete(root, data.toCharArray(), 0);
	}

	private int recursionDelete(Node node, char[] data, int i) {
		if (i >= data.length || node == null) {
			return 0;
		}
		int index = data[i] - 'a';
		int sum = 0;
		if (i == data.length -1) {
			sum = node.son[index].num;
			node.son[index].son = new Node[SIZE];
			node.son[index].num -= sum;
			return sum;
		}
		if (node.son[index] == null) {
			sum = 0;
			return sum;
		} else {
			sum = recursionDelete(node.son[index], data, i+1);
			node.son[index].num -= sum;
		}
		return sum;
	}

	public boolean search(String data) {
		if (data == null || data.length() == 0) {
			return false;
		}
		char[] arr = data.toCharArray();
		Node node = root;
		for (int i = 0; i < arr.length; i++) {
			int index = arr[i] - 'a';
			if (node.son[index] == null) {//前缀不存在，返回false
				return false;
			} else {
				node = node.son[index];//搜索下一个字符
			}
		}
//		return node.num > 0;
		return true;
	}
}

public class 百度之星资格赛_C {
	//创建缓冲输入流和输入流，加速输入输出
	static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

	public static int nextInt() throws IOException {
		in.nextToken();
		return (int) in.nval;
	}

	public static String next() throws IOException {
		in.nextToken();
		return in.sval;
	}
	
	public static void main(String[] args) throws Exception {
		int n = nextInt();
		Trie trie = new Trie();
		for (int i = 0; i < n; i++) {
			String order = next();
			String data = next();
			if(order.equals("insert")) {
				trie.insert(data);
			} else if(order.equals("delete")) {
				trie.delete(data);
			}else if(order.equals("search")){
				out.println(trie.search(data) ? "Yes" : "No");
				out.flush();
			}
		}
	}
}
